package dao

import (
	"user_srv/basic/config"
	"user_srv/handler/model"
)

// RecommendationService 推荐算法服务
// 基于兴趣相似度和地理位置为用户推荐合适的其他用户
type RecommendationService struct{}

// GetRecommendations 获取推荐用户列表
// 功能：为当前用户推荐合适的其他用户
// 推荐算法：
//  1. 获取当前用户资料和兴趣
//  2. 排除已滑动过的用户（避免重复推荐）
//  3. 排除已匹配的用户（已有聊天关系）
//  4. 基于兴趣相似度进行排序和推荐
//  5. 分页返回推荐结果
//
// 参数：
//   - userId: 当前用户ID
//   - page: 页码
//   - pageSize: 每页数量（默认10，最大50）
//
// 返回值：推荐用户列表（包含用户信息、兴趣爱好等）
func (r *RecommendationService) GetRecommendations(userId int64, page, pageSize int32) ([]RecommendedUserInfo, error) {
	// 设置默认值
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 10
	}
	if pageSize > 50 {
		pageSize = 50 // 限制最大页面大小
	}

	offset := (page - 1) * pageSize

	// 1. 获取当前用户资料和兴趣
	currentUser, err := r.getCurrentUserInfo(userId)
	if err != nil {
		return nil, err
	}

	// 2. 获取已滑动过的用户ID列表
	swipedUserIds, err := r.getSwipedUserIds(userId)
	if err != nil {
		return nil, err
	}

	// 3. 获取已匹配的用户ID列表
	matchedUserIds, err := r.getMatchedUserIds(userId)
	if err != nil {
		return nil, err
	}

	// 4. 排除已滑动和已匹配的用户
	var excludeUserIds []int64
	excludeUserIds = append(excludeUserIds, swipedUserIds...)
	excludeUserIds = append(excludeUserIds, matchedUserIds...)
	excludeUserIds = append(excludeUserIds, userId) // 排除自己

	// 5. 基于兴趣相似度和地理位置获取推荐用户
	recommendations, err := r.getRecommendationsByAlgorithm(currentUser, excludeUserIds, int(pageSize), int(offset))
	if err != nil {
		return nil, err
	}

	return recommendations, nil
}

// 获取当前用户信息
func (r *RecommendationService) getCurrentUserInfo(userId int64) (*UserInfo, error) {
	var profile model.XqUserProfiles
	err := config.DB.Where("user_id = ? AND is_active = 1", userId).First(&profile).Error
	if err != nil {
		return nil, err
	}

	// 获取用户兴趣标签
	var interests []model.XqUserInterests
	err = config.DB.Where("user_id = ?", userId).Find(&interests).Error
	if err != nil {
		return nil, err
	}

	var interestTagIds []int64
	for _, interest := range interests {
		interestTagIds = append(interestTagIds, interest.TagId)
	}

	return &UserInfo{
		UserId:         userId,
		Profile:        profile,
		InterestTagIds: interestTagIds,
	}, nil
}

// 获取已滑动过的用户ID列表
func (r *RecommendationService) getSwipedUserIds(userId int64) ([]int64, error) {
	var swipes []model.XqUserSwipes
	err := config.DB.Where("user_id = ?", userId).Find(&swipes).Error
	if err != nil {
		return nil, err
	}

	var userIds []int64
	for _, swipe := range swipes {
		userIds = append(userIds, swipe.TargetUserId)
	}
	return userIds, nil
}

// 获取已匹配的用户ID列表
func (r *RecommendationService) getMatchedUserIds(userId int64) ([]int64, error) {
	var matches []model.XqUserMatches
	err := config.DB.Where("(user_id1 = ? OR user_id2 = ?) AND is_active = 1", userId, userId).Find(&matches).Error
	if err != nil {
		return nil, err
	}

	var userIds []int64
	for _, match := range matches {
		if match.UserId1 == userId {
			userIds = append(userIds, match.UserId2)
		} else {
			userIds = append(userIds, match.UserId1)
		}
	}
	return userIds, nil
}

// 基于算法获取推荐用户
// 用户（currentUser）的兴趣标签（InterestTagIds），然后通过 SQL 子查询筛选出同样包含这些标签的其他用户（从 xq_user_interests 表中查询匹配的 user_id）
func (r *RecommendationService) getRecommendationsByAlgorithm(currentUser *UserInfo, excludeUserIds []int64, limit, offset int) ([]RecommendedUserInfo, error) {
	// 构建排除条件
	excludeCondition := ""
	if len(excludeUserIds) > 0 {
		excludeCondition = "AND p.user_id NOT IN ("
		for i := range excludeUserIds {
			if i > 0 {
				excludeCondition += ","
			}
			excludeCondition += "?"
		}
		excludeCondition += ")"
	}

	// 构建兴趣匹配条件
	interestCondition := ""
	var interestArgs []interface{}
	if len(currentUser.InterestTagIds) > 0 {
		interestCondition = "AND p.user_id IN (SELECT DISTINCT user_id FROM xq_user_interests WHERE tag_id IN ("
		for i, tagId := range currentUser.InterestTagIds {
			if i > 0 {
				interestCondition += ","
			}
			interestCondition += "?"
			interestArgs = append(interestArgs, tagId)
		}
		interestCondition += "))"
	}

	// 构建查询参数
	var args []interface{}

	// 添加排除用户参数
	for _, id := range excludeUserIds {
		args = append(args, id)
	}

	// 添加兴趣参数
	args = append(args, interestArgs...)

	// 添加分页参数
	args = append(args, limit, offset)

	// 执行查询
	query := `
		SELECT p.user_id, p.nickname, p.age, p.avatar, p.bio,
		       GROUP_CONCAT(t.name) as interests
		FROM xq_user_profiles p
		LEFT JOIN xq_user_interests ui ON p.user_id = ui.user_id
		LEFT JOIN xq_interest_tags t ON ui.tag_id = t.id
		WHERE p.is_active = 1 ` + excludeCondition + ` ` + interestCondition + `
		GROUP BY p.user_id, p.nickname, p.age, p.avatar, p.bio
		ORDER BY p.created_at DESC
		LIMIT ? OFFSET ?
	`

	rows, err := config.DB.Raw(query, args...).Rows()
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var recommendations []RecommendedUserInfo
	for rows.Next() {
		var rec RecommendedUserInfo
		var interests string
		err := rows.Scan(&rec.UserId, &rec.Nickname, &rec.Age, &rec.Avatar, &rec.Bio, &interests)
		if err != nil {
			continue
		}

		// 设置默认距离
		rec.Distance = -1 // 未知距离

		// 解析兴趣标签
		if interests != "" {
			rec.Interests = []string{interests}
		}

		recommendations = append(recommendations, rec)
	}

	return recommendations, nil
}

// UserInfo 用户信息结构体
// 包含用户基本资料和兴趣标签
// - UserId: 用户ID
// - Profile: 用户资料（昵称、头像、年龄等）
// - InterestTagIds: 用户选择的兴趣标签ID列表
type UserInfo struct {
	UserId         int64
	Profile        model.XqUserProfiles
	InterestTagIds []int64
}

// RecommendedUserInfo 推荐用户信息结构体
// 用于返回推荐用户的信息
// - UserId: 用户ID
// - Nickname: 昵称
// - Age: 年龄
// - Avatar: 头像URL
// - Bio: 个人简介
// - Interests: 兴趣标签列表
// - Distance: 距离（未知时为-1）
type RecommendedUserInfo struct {
	UserId    int64
	Nickname  string
	Age       int32
	Avatar    string
	Bio       string
	Interests []string
	Distance  int32
}
